﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _20190724
{
    /// <summary>
    /// 泛型方法：为了一个方法满足不同的类型的需求
    /// 泛型类：一个类，满足不同类型的需求
    /// 泛型接口：一个接口，满足不同类型的需求
    /// 泛型约束where T:Base
    /// 
    /// out协变 in逆变
    /// 
    /// 反射无处不在
    /// 反射破坏单例--反射调用私有构造函数
    /// MVC局限性--Action重载--反射是无法区分--只能通过 HttpMethod+特性
    /// 反射调用私有方法
    /// OOP
    /// 普通方法由编译时决定 --提高效率
    /// 虚方法由运行时决定的 --多态灵活
    /// 抽象方法由运行时决定的 --多态灵活
    /// 
    /// 抽象类：是一个父类+约束 单继承
    /// 接口：就是一个约束 只有多态变化 多实现
    /// 抽象类的出发点应该是代码重用 is a
    /// 接口纯粹为了约束，告诉别人一定有什么功能 can do
    /// 如果需要约束，一般选择接口，除非有代码需要重用
    ///
    /// 私有元素不能被继承
    ///
    /// 特性atrribute:就是一个类，直接或间接继承自Attribute
    /// AttibuteUsage
    /// 可以修饰参数，返回值，属性，方法，类
    /// 可以从类型 属性 方法 都可以获取特性实例，要求先IsDefined检测 在获取（实例化）
    /// 程序运行时可以找到特性--就可以发挥特性的作用，提供额外的行为
    /// 需要一个第三方的InvokeCenter,在这里去主动检测并且使用特性，才能提供功能
    /// 特性本事是没有用的
    /// 特性是在编译时确定的
    /// 
    /// 委托也是无处不在
    /// 委托的实例化 要其传递一个参数类型 返回值都跟委托一样的方法
    /// 委托就是一个类 这个类的实例可以放入一个方法，实例Invoke时，就调用方法 还是在执行方法
    /// 就是把方法放入了一个对象/变量
    /// 自上往下--逻辑解耦
    /// 自下网上--代码重用，去掉重复代码
    /// Action Func框架预定义的委托
    /// 委托是一种类型
    /// 事件是委托类型的一个实例 
    /// 
    /// Lambda
    /// 匿名方法 delegate关键字
    /// 拓展方法调用，很像实例方法， 拓展方法与实例方法同名，优先调用实例方法
    /// 少为object 没有约束的泛型去拓展
    /// Linq
    /// Linq To Object Enumerable 指的是内存数据
    /// Linq To Sql Queryable 操作数据库
    /// 
    /// 设计模式 解决具体问题的套路
    /// 六大原则 开发过程中，推荐的一些指导性原则
    /// 单一职责原则：一个类只负责一件事儿
    /// 里氏替换原则：任何使用基类的地方，都可以透明的使用其子类
    /// 父类有的，子类是必须有的
    /// 声明属性，字段，变量尽量声明为父类
    /// 迪米特法则（最少知道原则）：一个对象应该对其他对象保持最少的了解
    /// 类与类之间的关系
    /// 纵向：继承 实现
    /// 横向：聚合>组合>关联>依赖
    /// 
    /// 门面模式 中介者模式 分层封装
    /// 门面模式--上层交互门面--门面依赖子系统
    /// 
    /// 依赖倒置原则：高层模块不应该依赖于低层模块，二者应该通过抽象依赖
    /// 抽象
    /// 细节
    /// 面向抽象编程
    /// 
    /// 接口隔离原则：客户端不应该依赖它不需要的接口
    ///                 一个类对另一个类的依赖应该建立在最小的接口上
    /// 按照功能的密不可分来定义接口，而且应该是动态的，随着业务发展会有变化的
    /// 
    /// 开闭原则：对拓展开放，对修改关闭
    /// 修改：修改现有代码
    /// 拓展：增加代码
    /// 
    /// 表达式目录树：语法树，是一个数据结构
    /// 上端组装，下端去解析
    /// 
    /// IO序列化
    /// 
    /// MD5:不可逆加密 密文无法破解出原文
    /// 摘要 防篡改
    /// Des：对称可逆加密 加密后能解密回原文 加密key和解密key是一个
    /// RSA：非对称可逆加密 加密后能解密回原文 加密key和解密key不是一个
    /// 
    /// 设计模式
    /// 创建型设计模式：关注对象的创建
    /// 结构型设计模式：关注类与类之间的关系
    /// 行为型设计模式：关注对象和行为的分离
    /// 单利模式：new对象用时比较久
    /// 饿汉式：静态构造函数 第一次使用类之前 由CLR保证，初始化且只初始化一次
    /// 懒汉式：静态方法生成实例
    /// 原型模式：
    /// 简单工厂
    /// 工厂方法
    /// 抽象工厂
    /// 建造者模式：复杂的工厂方法
    /// 代理模式：vpn代理 火车票代理 没有什么技术问题是包一层不能解决的，避免修改业务类，只需要修改代理类
    /// 适配器模式：解决重构的问题
    /// 巅峰之作**装饰器模式：通过组合+继承 完成对象功能的动态拓展
    /// 外观模式，组合模式，桥接模式，享元模式
    /// 模板方法设计模式：在基类父类定义流程，把可变逻辑分离到不同子类实现
    /// 观察者模式：一个对象动作触发多个对象的行为
    /// 追求下端稳定，上端变化，
    /// 巅峰之作**责任链模式：请求的处理流程，沿着链子顺序执行，还运行链子拓展和订制
    /// 甩锅大法
    /// 
    /// AOP面向切面编程：允许开发者动态的修改静态的OO模型，是一种编程思想，是OOP思想的补充
    /// 类--功能点--模块--系统
    /// 
    /// 同步异步：
    ///     同步方法：发起调用，完成后才继续下一行
    ///     异步方法：发起调用，不等待完成，直接进入下一行
    ///     异步多线程去发短信
    ///     并行：多核之间叫并行
    ///     并发：CPU分片的并发
    /// 
    /// ManualResetEvent mre = new ManualResetEvent(false);
    /// false--关闭--Set打开--true--WaitOne就能通过
    /// true--打开--Reset关闭--false--WaitOne就只能等待
    /// ThreadPool的线程都是后台线程
    /// TASK基于线程池
    /// 线程池是单例的，全局唯一的
    /// 
    /// 网络爬虫
    /// 
    /// await/async 是C#保留关键字，通常是成对出现
    /// async修饰方法，可以单独出现，但是有警告
    /// await在方法体，只能出现在task/async方法前，只有await会报错
    /// 主线程调用async/await方法，主线程遇到await返回执行后续动作，
    /// await后面的代码会等着task任务的完成后再继续执行
    /// 其实就像把await后面的代码包装成一个continue的回调动作
    /// 然后这个回调动作可能是Task线程，也可能是新的子线程，也可能是主线程
    /// 一个async方法，如果没有返回值，可以方法声明返回Task
    /// 
    /// IOC控制反转：传统开发，上端依赖（调用/指定）下端对象，会有依赖
    /// 把对下端对象的依赖转移到第三方容器（工厂+配置文件+反射）
    /// 能够程序拥有更好的拓展性
    /// DI依赖注入：依赖注入就是能做到构造某个对象时，将依赖的对象自动初始化并注入
    /// IOC是目标是效果，需要DI依赖注入的手段
    /// 
    /// Unity容器
    /// IOC
    /// 
    /// 数据库设计
    ///     需求分析
    ///     概要设计 E-R图 表-属性-关系图，多方沟通问题
    ///     详细设计，细致到表--字段
    /// 
    /// 权限模块
    ///     做视图
    ///     自动保存最终结果，修改用户后直接保存在用户表，加个字段
    ///     程序缓存
    ///     
    /// 读写分离
    ///     一主多从，主库写从库读
    ///     数据同步，从主库到从库（有延迟）
    ///     
    ///     分库，分表，表分区
    ///     垂直分库：按业务拆分库，不同库不同的服务器
    ///     水平分库：每个库结构一致数据不一致
    /// 
    ///     分表
    ///         垂直分表：减小表体积，提升增删改查的效率
    ///         水平分表：地域/时间/类别
    ///     按城市拆分
    ///     按时间拆分
    ///     随机算法
    ///     
    ///     跨库跨表Join---很不推荐
    ///     汇总表---专门应对特殊要求
    ///     业务妥协
    ///     值类型的长度是确定的，引用类型的长度是不确定的
    ///     
    /// 享元模式内存分配
    ///     
    /// 系统性能优化的第一步，就是使用缓存
    ///     客户端缓存
    ///     CDN缓存
    ///     反向代理缓存
    ///     服务器缓存
    ///     
    /// 线程安全容器ConcurrentDictionary
    /// 队列，链表
    /// 
    /// Redis:远程字典服务器
    ///     基于内存管理，实现了5种数据结构，单线程模型的应用程序
    ///     Redis就是为开发而生，会为各种开发需求提供对应的解决方案
    ///     只是为了提升性能，不做数据标准，任何的数据固化都是数据库完成的，不能代替数据库
    ///     
    /// EntityFramework
    /// 映射：
    ///     1 特性映射
    ///     2 OnModelCreating完成链式映射
    ///     3 映射类文件
    /// Find可以使用缓存，优先从内存查找
    /// 但是linq时不能用缓存，每次都是要查询的
    /// AsNoTracking() 如果数据不会更新，加一个会提升性能
    /// 
    /// WCF项目组之间调用的 不对外提供服务
    /// WebApi Restful架构风格
    /// 
    /// 
    ///  46节完    分
    ///  47节完    分
    ///  48节完    分
    ///  49节完
    ///  50节完
    ///  51节完
    ///  52节完
    ///  53
    ///  54
    ///  55节完    分
    ///  56节完    分
    ///  57节完    分
    ///  58节完    分
    ///  
    /// 
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            //int iValue = 1;AAAAAA
            //CommonMethod.Show<int>(iValue);
            //DerivedClass Bs1 = new DerivedClass();
            //DerivedClass Bs2 = new DerivedClass(1);

            Console.ReadKey();
        }
    }

    #region 11
    public class BassClass
    {
        int number;
        public BassClass()
        {
            Console.WriteLine("子类调用基类的第一个构造函数");
        }
        public BassClass(int i)
        {
            number = i;
            Console.WriteLine($"{i}子类调用基类的第二个构造函数");
        }
        public int GetNumber()
        {
            return number;
        }
    }
    public class DerivedClass: BassClass
    {
        public DerivedClass()
        {
            Console.WriteLine("子类的构造函数  ");
        }
        public DerivedClass(int i):base(i)
        {
            Console.WriteLine($"{i}子类的第二个构造函数");
        }
    }
    #endregion

}
